Declarative Ajax Web Applications through SQL++ on a Unified Application State

Implementing even a conceptually simple web application requires an inordinate amount of time. FORWARD addresses three problems that reduce developer productivity: (a) Impedance mismatch across the multiple languages used at different tiers of the application architecture. (b) Distributed data access across the multiple data sources of the application (SQL database, user input of the browser page, session data in the application server, etc). (c) Asynchronous, incremental modification of the pages, as performed by Ajax actions. FORWARD belongs to a novel family of web application frameworks that attack impedance mismatch by offering a single unifying language. FORWARD's language is SQL++, a minimally extended SQL. FORWARD's architecture is based on two novel cornerstones: (a) A Unified Application State (UAS), which is a virtual database over the multiple data sources. The UAS is accessed via distributed SQL++ queries, therefore resolving the distributed data access problem. (b) Declarative page specifications, which treat the data displayed by pages as rendered SQL++ page queries. The resulting pages are automatically incrementally modified by FORWARD. User input on the page becomes part of the UAS. We show that SQL++ captures the semi-structured nature of web pages and subsumes the data models of two important data sources of the UAS: SQL databases and JavaScript components. We show that simple markup is sufficient for creating Ajax displays and for modeling user input on the page as UAS data sources. Finally, we discuss the page specification syntax and semantics that are needed in order to avoid race conditions and conflicts between the user input and the automated Ajax page modifications. FORWARD has been used in the development of eight commercial and academic applications. An alpha-release web-based IDE (itself built in FORWARD) enables development in the cloud.Comment: Proceedings of the 14th International Symposium on Database Programming Languages (DBPL 2013), August 30, 2013, Riva del Garda, Trento, Ital

The Outcome of HyperCVAD Combined with Alemtuzumab for the Treatment of Aggressive T-Cell and NK-Cell Neoplasms.

We report our experience in using six cycles of hyperCVAD in combination with alemtuzumab for the treatment of aggressive T-cell and NK/T-cell neoplasms. Seven females and six males with the median age of 41 (range 18–60) diagnosed with T-cell acute lymphoblastic lymphoma and peripheral T-cell and NK/T-cell neoplasms (nPTCL = 6, nT-cell ALL = 3, nNK/T-cell neoplasms = 4) from 2006 to 2008 were treated with alemtuzumab–hyperCVAD regimen. A total of nine patients (69%) responded to the regimen, with seven achieved complete remission and two achieved partial remission. The median progression free survival and overall survival duration among the responders with complete remission were 12.9 and 24.9 months respectively. The incidence of relapse among the responders was 44% and the overall survival rate was 23%. Only four (31%) patients completed the six cycles of alemtuzumab– hyperCVAD. Others were stopped earlier due to progressive disease (n = 2), cytomegalovirus (CMV) reactivation and/or disease (n = 3), death not due to disease (n = 2), and patient’s refusal to continue alemtuzumab (n = 2). The incidence of death not due to disease, CMV reactivation and recurrent CMV reactivation were 50, 50 and 17%, respectively. This study shows that alemtuzumab in combination with hyperCVAD regimen is a feasible regimen but with high toxicity. The toxicity might be reduced with the incorporation of filgrastim and use of valganciclovir as CMV prophylaxis

Web application creation made easy : a SQL-driven rapid development framework and a Do-It- Yourself platform

Building, installing and evolving a custom web application, even one which comprises only Create, Read, Update and Delete (CRUD) pages accessing a single database, is time consuming and expensive. We present two complementary systems that enable the rapid creation, customization and evolution of such a database-driven web application and its pages thereof: a rapid application development framework called FORWARD, and a Do-It-Yourself (DIY) platform called app2you. FORWARD simplifies the development of AJAX web pages by treating them as rendered views, where the programmer specifies a view using visual units and (minimally extended) SQL. Such a declarative approach leads to significantly less code, as the framework automatically solves performance optimization problems that the programmer would otherwise hand-code. Since the pages are fueled by views, FORWARD leverages years of database research on incremental view maintenance by creating optimization techniques appropriately extended for the need of pages (nesting, variability, ordering), thereby achieving performance comparable to hand-coded applications. app2you builds on FORWARD by empowering non- programmer business process owners to create and customize application pages, without programming or database design in a conventional sense. app2you provides a WYSIWYG design facility where the owner specifies the application by manipulating visual aspects of it, responding to questions posed by wizards and setting configuration options. In response, the design facility infers the necessary FORWARD application, including database schema, data structures and code, and immediately produces a revision of the application for the owner's evaluation. The software development cycle is shortened to literally second

Ajax-based Report Pages as Incrementally Rendered Views

While Ajax-based programming enables faster performance and higher interface quality over pure server-side programming, it is demanding and error prone as each action that partially updates the page requires custom, ad-hoc code. The problem is exacerbated by distributed programming between the browser and server, where the developer uses JavaScript to access the page state and Java/SQL for the database. The FORWARD framework simplifies the development of Ajax pages by treating them as rendered views, where the developer declares a view using an extension of SQL and page units, which map to the view and render the data in the browser. Such a declarative approach leads to significantly less code, as the framework automatically solves performance optimization problems that the developer would otherwise hand-code. Since pages are fueled by views, FORWARD leverages years of database research on incremental view maintenance by creating optimization techniques appropriately extended for the needs of pages (nesting, variability, ordering), thereby achieving performance comparable to hand-coded JavaScript/Java applications